package com.agile.leetcode.SyntacticSugar;


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * @Author ChenZhangKun
 * @Date 2020/12/8 9:25
 */
public class SyntacticSugar {
    public static void main(String[] args) {
        // 泛型和静态变量
        TD<String> td = new TD<>();
        TD<Integer> td1 = new TD<>();
        // java语法糖，运行的时候会将泛型擦除
        td.i = 1;
        td1.i = 2;
        System.out.println(td.i);
    }
}

class TD<T> {
    public static int i = 0;

    public void method(T t) {
    }
}

class BreakBox {
    public static void main(String[] args) {
        // java语法糖，自动拆箱与装箱
        Integer a = 1000;
        Integer b = 1000;
        Integer c = 100;
        Integer d = 100;
        System.out.println("a == b is " + (a == b));
        System.out.println(("c == d is " + (c == d)));

        int i = 10;
        // 自动装箱，此时编译器会调用  Integer.valueOf(i);
        Integer n = i;

        Integer m = 10;
        // 自动拆箱，此时编译器会调用 m.intValue();
        int k = m;
    }
}

/**
 * switch语法糖
 */
class switchDemoString {
    public static void main(String[] args) {
        String str = "world";
        switch (str) {
            case "hello":
                System.out.println("hello");
                break;
            case "world":
                System.out.println("world");
                break;
            default:
                break;
        }
    }
}

/**
 * switch反编译后的代码
 * 看到这个代码，你知道原来字符串的switch是通过equals()和hashCode()方法来实现的。还好hashCode()方法返回的是int，而不是long。
 */
class switchDemoString_Decompiling {
    public switchDemoString_Decompiling() {
    }

    public static void main(String args[]) {
        String str = "world";
        String s;
        switch ((s = str).hashCode()) {
            default:
                break;
            case 99162322:
                if (s.equals("hello"))
                    System.out.println("hello");
                break;
            case 113318802:
                if (s.equals("world"))
                    System.out.println("world");
                break;
        }
    }
}

class VariableParameter {
    public static void main(String[] args) {
        print("Holis", "公众号:Hollis", "博czk", "QQ：907607222");
    }

    public static void print(String... strs) {
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
    }
}

/**
 * 可变参数反编译后的代码
 * 从反编译后代码可以看出，可变参数在被使用的时候，他首先会创建一个数组，数组的长度就是调用该方法是传递的实参的个数，
 * 然后再把参数值全部放到这个数组当中，然后再把这个数组作为参数传递到被调用的方法中
 */
class VariableParameter_DeCompile {
    public static void main(String args[]) {
        print(new String[]{
                "Holis", "\u516C\u4F17\u53F7:Hollis", "\u535A\u5BA2\uFF1Awww.hollischuang.com", "QQ\uFF1A907607222"
        });
    }

    public static void print(String strs[]) {
        for (int i = 0; i < strs.length; i++)
            System.out.println(strs[i]);

    }
}

/**
 * 枚举
 */
enum m {
    SPRING, SUMMER;
}
 /*final class M extends Enum
{
    private T(String s, int i)
    {
        super(s, i);
    }
    public static <T> T[] values()
    {
        T at[];
        int i;
        T at1[];
        System.arraycopy(at = ENUM$VALUES, 0, at1 = new T[i = at.com.agile.leetcode.array.length], 0, i);
        return at1;
    }

    public static T valueOf(String s)
    {
        return (T)Enum.valueOf(demo/T, s);
    }

    public static final T SPRING;
    public static final T SUMMER;
    private static final T ENUM$VALUES[];
    static
    {
        SPRING = new T("SPRING", 0);
        SUMMER = new T("SUMMER", 1);
        ENUM$VALUES = (new T[] {
                SPRING, SUMMER
        });
    }
}*/

/**
 * 条件编译
 */
class ConditionalCompilation {
    public static void main(String[] args) {
        final boolean DEBUG = true;
        if (DEBUG) {
            System.out.println("Hello, DEBUG!");
        }

        final boolean ONLINE = false;

        if (ONLINE) {
            System.out.println("Hello, ONLINE!");
        }
    }
}

/**
 * 编译后的文件
 * 所以，Java语法的条件编译，是通过判断条件为常量的if语句实现的。根据if判断条件的真假，编译器直接把分支为false的代码块消除。
 * 通过该方式实现的条件编译，必须在方法体内实现，而无法在正整个Java类的结构或者类的属性上进行条件编译。
 */
class ConditionalCompilation_DeCompile {
    public ConditionalCompilation_DeCompile() {
    }

    public static void main(String args[]) {
        boolean DEBUG = true;
        System.out.println("Hello, DEBUG!");
        boolean ONLINE = false;
    }
}

/**
 * 在java 7中，数值字面量，不管是整数还是浮点数，都允许在数字之间插入任意多个下划线。
 * 这些下划线不会对字面量的数值产生影响，目的就是方便阅读。
 */
class Test {
    public static void main(String... args) {
        int i = 10_000;
        System.out.println(i);
    }
}

/**
 * java 反编译后的
 * 反编译后就是把_删除了。也就是说编译器并不认识在数字字面量中的_，需要在编译阶段把他去掉。
 */
class Test_DeCompile {
    public static void main(String[] args) {
        int i = 10000;
        System.out.println(i);
    }
}

/**
 * 增强for循环（for-each）相信大家都不陌生，日常开发经常会用到的，他会比for循环要少写很多代码，那么这个语法糖背后是如何实现的呢？
 */
class ForEach {
    public static void main(String... args) {
        String[] strs = {"Hollis", "公众号：Hollis", "博客：www.hollischuang.com"};
        for (String s : strs) {
            System.out.println(s);
        }
        List<String> strList = Arrays.asList("Hollis", "公众号：Hollis", "博客：www.hollischuang.com");
        for (String s : strList) {
            System.out.println(s);
        }
    }
}

/**
 * 反编译后的代码
 * 反编译后为普通遍历和迭代器遍历
 */
class ForEach_DeCompile {
    public static void main(String args[]) {
        String strs[] = {
                "Hollis", "\u516C\u4F17\u53F7\uFF1AHollis", "\u535A\u5BA2\uFF1Awww.hollischuang.com"
        };
        String args1[] = strs;
        int i = args1.length;
        for (int j = 0; j < i; j++) {
            String s = args1[j];
            System.out.println(s);
        }

        List strList = Arrays.asList("Hollis", "\u516C\u4F17\u53F7\uFF1AHollis", "\u535A\u5BA2\uFF1Awww.hollischuang.com");
        String s;
        for (Iterator iterator = strList.iterator(); iterator.hasNext(); System.out.println(s))
            s = (String) iterator.next();

    }
}

/**
 * java语法糖
 * 从Java 7开始，jdk提供了一种更好的方式关闭资源，使用try-with-resources语句
 * 自己不用关闭io流
 * 编译器会帮你关闭io流
 */
class TryWithResource {
    public static void main(String... args) {
        try (BufferedReader br = new BufferedReader(new FileReader("d:\\ hollischuang.xml"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            // handle exception
        }
    }
}
